home *** CD-ROM | disk | FTP | other *** search
/ Just Call Me Internet / Just Call Me Internet.iso / prog / atari / m2 / cat3src / magic / i / magicdos.i < prev    next >
Encoding:
Modula Implementation  |  1997-10-26  |  14.5 KB  |  992 lines
  1. (*----------------------------------------------------------------------*
  2.  *                                                                      *
  3.  *         MAGIC   Modula's  All purpose  GEM  Interface  Cadre         *
  4.  *                 ÿ         ÿ            ÿ    ÿ          ÿ             *
  5.  *----------------------------------------------------------------------*
  6.  * Version 3.30  02.02.1992     (C)90/91/92 by Peter Hellinger Software *
  7.  *----------------------------------------------------------------------*
  8.  *            Dieses Modul ist urheberrechtlich geschtzt.              *
  9.  *                                                                      *
  10.  * Die Ver”ffentlichung des Quelltextes oder Teilen daraus in schrift-  *
  11.  * licher Form, insbesondere in Zeitschriften, sowie die Verbreitung    *
  12.  * ber Public-Domain-H„ndler bedarf der ausdrcklichen schriftlichen   *
  13.  * Genehmigung des Autors!                                              *
  14.  *                                                                      *
  15.  * Der Autor gibt hiermit die ausdrckliche Erlaubnis, das Modul jeder- *
  16.  * zeit auch im Quelltext weiterzugegeben, sofern dessen Text und ins-  *
  17.  * besondere dieser Urheberrechts-Vermerk nicht ver„ndert wird, und     *
  18.  * durch die Weitergabe kein finanzieller Nutzen entsteht. Der Autor    *
  19.  * beh„lt sich das Recht vor, diese Erlaubnis jederzeit u. ohne Angaben *
  20.  * von Grnden zu widerrufen.                                           *
  21.  *----------------------------------------------------------------------*)
  22.  
  23. IMPLEMENTATION MODULE MagicDOS;
  24.  
  25. (*----------------------------------------------------------------------*
  26.  * Int. Vers | Datum    | Name | Žnderung                               *
  27.  *-----------+----------+------+----------------------------------------*
  28.  *  3.00     | 18.01.92 |  Hp  |                                        *
  29.  *-----------+----------+------+----------------------------------------*)
  30.  
  31.  
  32.  
  33. (* IMPLEMENTATION FšR  >>> Megamax-Modula-2 <<< *)
  34. (*                                              *)
  35. (*$R-   Range-Checks                            *)
  36. (*$S-   Stack-Check                             *)
  37. (*                                              *)
  38. (*----------------------------------------------*)
  39.  
  40.  
  41.  
  42.  
  43.  
  44.  
  45. FROM MagicSys   IMPORT  Nil, Null, Bit0, Bit1, Bit2, Bit3, Bit4, Bit5, Bit6,
  46.                         Bit7, Bit8, Bit9, Bit10, Bit11, Bit12, Bit13, Bit14,
  47.                         Bit15, LOC, Byte, ByteSet, sWORD, sINTEGER, sCARDINAL,
  48.                         sBITSET, lINTEGER, lCARDINAL, lWORD, lBITSET,
  49.                         CastToChar, CastToByte, CastToByteset, CastToInt,
  50.                         CastToCard, CastToBitset, CastToWord, CastToLInt,
  51.                         CastToLCard, CastToLBitset, CastToLWord, CastToAddr,
  52.                         TosVersion, Accessory, Basepage, SysHeader, TosDate;
  53.  
  54.  
  55.  
  56.  
  57.  
  58.  
  59. IMPORT MagicSys;
  60.  
  61.  
  62. FROM SYSTEM IMPORT ADDRESS, ADR, WORD, ASSEMBLER;
  63.  
  64. VAR     lc:     lCARDINAL;
  65.         li:     lINTEGER;
  66.         lb:     lBITSET;
  67.         i:      sINTEGER;
  68.         c:      sCARDINAL;
  69.         s:      sBITSET;
  70.         a:      ADDRESS;
  71.         x:      sCARDINAL;
  72.  
  73.  
  74.  
  75.  
  76.  
  77. PROCEDURE Pterm0;
  78. BEGIN
  79.  
  80.  ASSEMBLER
  81.   MOVE.W  #0, -(SP)
  82.   TRAP    #1
  83.  END;
  84.  
  85.  
  86.  
  87.  
  88. END Pterm0;
  89.  
  90. PROCEDURE Cconin (): lCARDINAL;
  91. BEGIN
  92.  
  93.  ASSEMBLER
  94.   MOVE.W  #1, -(SP)
  95.   TRAP    #1
  96.   ADDQ.L  #2, SP
  97.   MOVE.L  D0, lc
  98.  END;
  99.  RETURN lc;
  100.  
  101.  
  102.  
  103.  
  104. END Cconin;
  105.  
  106. PROCEDURE Cconout (ch: CHAR);
  107. BEGIN                  
  108.  
  109.  x:= ORD(ch);
  110.  ASSEMBLER
  111.   MOVE.W  x, -(SP)
  112.   MOVE.W  #2, -(SP)
  113.   TRAP    #1
  114.   ADDQ.L  #4, SP
  115.  END;
  116.  
  117.  
  118.  
  119.  
  120. END Cconout;
  121.  
  122. PROCEDURE Cauxin (): sCARDINAL;
  123. BEGIN
  124.  
  125.  ASSEMBLER
  126.   MOVE.W  #3, -(SP)
  127.   TRAP    #1
  128.   ADDQ.L  #2, SP
  129.   MOVE.W  D0, c
  130.  END;
  131.  RETURN c;
  132.  
  133.  
  134.  
  135.  
  136. END Cauxin;
  137.  
  138. PROCEDURE Cauxout (ch: CHAR);
  139. BEGIN
  140.  
  141.  x:= ORD (ch);
  142.  ASSEMBLER
  143.   MOVE.W  x, -(SP)
  144.   MOVE.W  #4, -(SP)
  145.   TRAP    #1
  146.   ADDQ.L  #4, SP
  147.  END;
  148.  
  149.  
  150.  
  151.  
  152. END Cauxout;
  153.  
  154. PROCEDURE Cprnout (ch: CHAR);
  155. BEGIN
  156.  
  157.  x:= ORD (ch);
  158.  ASSEMBLER
  159.   MOVE.W  x, -(SP)
  160.   MOVE.W  #5, -(SP)
  161.   TRAP    #1
  162.   ADDQ.L  #4, SP
  163.  END;
  164.  
  165.  
  166.  
  167.  
  168. END Cprnout;
  169.  
  170. PROCEDURE Crawio (ch: CHAR): lCARDINAL;
  171. BEGIN
  172.  
  173.  x:= ORD (ch);
  174.  ASSEMBLER
  175.   MOVE.W  x, -(SP)
  176.   MOVE.W  #6, -(SP)
  177.   TRAP    #1
  178.   ADDQ.L  #4, SP
  179.   MOVE.L  D0, lc
  180.  END;
  181.  RETURN lc;
  182.  
  183.  
  184.  
  185.  
  186. END Crawio;
  187.  
  188. PROCEDURE Crawin (): lCARDINAL;
  189. BEGIN
  190.  
  191.  ASSEMBLER
  192.   MOVE.W  #7, -(SP)
  193.   TRAP    #1
  194.   ADDQ.L  #2, SP
  195.   MOVE.L  D0, lc
  196.  END;
  197.  RETURN lc;
  198.  
  199.  
  200.  
  201.  
  202. END Crawin;
  203.  
  204. PROCEDURE Cnecin (): lCARDINAL;
  205. BEGIN
  206.  
  207.  ASSEMBLER
  208.   MOVE.W  #8, -(SP)
  209.   TRAP    #1
  210.   ADDQ.L  #2, SP
  211.   MOVE.L  D0, lc
  212.  END;
  213.  RETURN lc;
  214.  
  215.  
  216.  
  217.  
  218. END Cnecin;
  219.  
  220. PROCEDURE Cconws (REF string: ARRAY OF CHAR);
  221. BEGIN
  222.  
  223.  ASSEMBLER
  224.   MOVE.L  string(A6), -(SP)
  225.   MOVE.W  #9, -(SP)
  226.   TRAP    #1
  227.   ADDQ.L  #6, SP
  228.  END;
  229.  
  230.  
  231.  
  232.  
  233. END Cconws;
  234.  
  235. PROCEDURE Cconrs (VAR string: ARRAY OF CHAR);
  236. BEGIN
  237.  
  238.  ASSEMBLER
  239.   MOVE.L  string(A6), -(SP)
  240.   MOVE.W  #10, -(SP)
  241.   TRAP    #1
  242.   ADDQ.L  #6, SP
  243.  END;
  244.  
  245.  
  246.  
  247.  
  248. END Cconrs;
  249.  
  250. PROCEDURE Cconis (): BOOLEAN;
  251. BEGIN
  252.  
  253.  ASSEMBLER
  254.   MOVE.W  #11, -(SP)
  255.   TRAP    #1
  256.   ADDQ.L  #2, SP
  257.   MOVE.W  D0, x
  258.  END;
  259.  RETURN x # 0;
  260.  
  261.  
  262.  
  263.  
  264. END Cconis;
  265.  
  266. PROCEDURE Dsetdrv (drive: sCARDINAL; VAR drvmap: lBITSET);
  267. BEGIN
  268.  
  269.  ASSEMBLER
  270.   MOVE.W  drive(A6), -(SP)
  271.   MOVE.W  #14, -(SP)
  272.   TRAP    #1
  273.   ADDQ.L  #4, SP
  274.   MOVE.L  D0, lb
  275.  END;
  276.  drvmap:= lb;
  277.  
  278.  
  279.  
  280.  
  281. END Dsetdrv;
  282.  
  283. PROCEDURE Cconos (): BOOLEAN;
  284. BEGIN
  285.  
  286.  ASSEMBLER
  287.   MOVE.W  #16, -(SP)
  288.   TRAP    #1
  289.   ADDQ.L  #2, SP
  290.   MOVE.W  D0, c
  291.  END;
  292.  RETURN c # 0;
  293.  
  294.  
  295.  
  296.  
  297. END Cconos;
  298.  
  299. PROCEDURE Cprnos (): BOOLEAN;
  300. BEGIN
  301.  
  302.  ASSEMBLER
  303.   MOVE.W  #17, -(SP)
  304.   TRAP    #1
  305.   ADDQ.L  #2, SP
  306.   MOVE.W  D0, c
  307.  END;
  308.  RETURN c # 0;
  309.  
  310.  
  311.  
  312.  
  313. END Cprnos;
  314.  
  315. PROCEDURE Cauxis (): BOOLEAN;
  316. BEGIN
  317.  
  318.  ASSEMBLER
  319.   MOVE.W  #18, -(SP)
  320.   TRAP    #1
  321.   ADDQ.L  #2, SP
  322.   MOVE.W  D0, c
  323.  END;
  324.  RETURN c # 0;
  325.  
  326.  
  327.  
  328.  
  329. END Cauxis;
  330.  
  331. PROCEDURE Cauxos (): BOOLEAN;
  332. BEGIN
  333.  
  334.  ASSEMBLER
  335.   MOVE.W  #19, -(SP)
  336.   TRAP    #1
  337.   ADDQ.L  #2, SP
  338.   MOVE.W  D0, c
  339.  END;
  340.  RETURN c # 0;
  341.  
  342.  
  343.  
  344.  
  345. END Cauxos;
  346.  
  347. PROCEDURE Dgetdrv (): sCARDINAL;
  348. BEGIN
  349.  
  350.  ASSEMBLER
  351.   MOVE.W  #25, -(SP)
  352.   TRAP    #1
  353.   ADDQ.L  #2, SP
  354.   MOVE.W  D0, c
  355.  END;
  356.  RETURN c;
  357.  
  358.  
  359.  
  360.  
  361. END Dgetdrv;
  362.  
  363. PROCEDURE Fsetdta (dta: ADDRESS);
  364. BEGIN
  365.  
  366.  ASSEMBLER
  367.   MOVE.L  dta(A6), -(SP)
  368.   MOVE.W  #26, -(SP)
  369.   TRAP    #1
  370.   ADDQ.L  #6, SP
  371.  END;
  372.  
  373.  
  374.  
  375.  
  376. END Fsetdta;
  377.  
  378. PROCEDURE Super (VAR stack: ADDRESS);
  379. BEGIN
  380.  
  381.  a:= stack;
  382.  ASSEMBLER
  383.   MOVE.L  a, -(SP)
  384.   MOVE.W  #32, -(SP)
  385.   TRAP    #1
  386.   ADDQ.L  #6, SP
  387.   MOVE.L  D0, a
  388.  END;
  389.  stack:= a;
  390.  
  391.  
  392.  
  393.  
  394. END Super;
  395.  
  396. PROCEDURE Tgetdate (): sCARDINAL;
  397. BEGIN
  398.  
  399.  ASSEMBLER
  400.   MOVE.W  #42, -(SP)
  401.   TRAP    #1
  402.   ADDQ.L  #2, SP
  403.   MOVE.W  D0, c
  404.  END;
  405.  RETURN c;
  406.  
  407.  
  408.  
  409.  
  410. END Tgetdate;
  411.  
  412. PROCEDURE Tsetdate (date: sCARDINAL);
  413. BEGIN
  414.  
  415.  c:= date;
  416.  ASSEMBLER
  417.   MOVE.W  c, -(SP)
  418.   MOVE.W  #43, -(SP)
  419.   TRAP    #1
  420.   ADDQ.L  #4, SP
  421.  END;
  422.  
  423.  
  424.  
  425.  
  426. END Tsetdate;
  427.  
  428. PROCEDURE Tgettime (): sCARDINAL;
  429. BEGIN
  430.  
  431.  ASSEMBLER
  432.   MOVE.W  #44, -(SP)
  433.   TRAP    #1
  434.   ADDQ.L  #2, SP
  435.   MOVE.W  D0, c
  436.  END;
  437.  RETURN c;
  438.  
  439.  
  440.  
  441.  
  442. END Tgettime;
  443.  
  444. PROCEDURE Tsettime (time: sCARDINAL);
  445. BEGIN
  446.  
  447.  c:= time;
  448.  ASSEMBLER
  449.   MOVE.W  c, -(SP)
  450.   MOVE.W  #45, -(SP)
  451.   TRAP    #1
  452.   ADDQ.L  #4, SP
  453.  END;
  454.  
  455.  
  456.  
  457.  
  458. END Tsettime;
  459.  
  460. PROCEDURE Fgetdta (): ADDRESS;
  461. BEGIN
  462.  
  463.  ASSEMBLER
  464.   MOVE.W  #47, -(SP)
  465.   TRAP    #1
  466.   ADDQ.L  #2, SP
  467.   MOVE.L  D0, a
  468.  END;
  469.  RETURN a;
  470.  
  471.  
  472.  
  473.  
  474. END Fgetdta;
  475.  
  476. PROCEDURE Sversion (): sCARDINAL;
  477. BEGIN
  478.  
  479.  ASSEMBLER
  480.   MOVE.W  #48, -(SP)
  481.   TRAP    #1
  482.   ADDQ.L  #2, SP
  483.   MOVE.W  D0, c
  484.  END;
  485.  RETURN c;
  486.  
  487.  
  488.  
  489.  
  490. END Sversion;
  491.  
  492. PROCEDURE Ptermres (keep: lCARDINAL; return: sCARDINAL);
  493. BEGIN
  494.  
  495.  c:= return;  lc:= keep;
  496.  ASSEMBLER
  497.   MOVE.W  c, -(SP)
  498.   MOVE.L  lc, -(SP)
  499.   MOVE.W  #49, -(SP)
  500.   TRAP    #1
  501.  END;
  502.  
  503.  
  504.  
  505.  
  506. END Ptermres;
  507.  
  508. PROCEDURE Dfree (VAR dib: ARRAY OF LOC; drive: sCARDINAL);
  509. BEGIN
  510.  
  511.  c:= drive;
  512.  ASSEMBLER
  513.   MOVE.W  c, -(SP)
  514.   MOVE.L  dib(A6), -(SP)
  515.   MOVE.W  #54, -(SP)
  516.   TRAP    #1
  517.   ADDQ.L  #8, SP
  518.  END;
  519.  
  520.  
  521.  
  522.  
  523. END Dfree;
  524.  
  525. PROCEDURE Dcreate (REF pfad: ARRAY OF CHAR): sINTEGER;
  526. BEGIN
  527.  
  528.  ASSEMBLER
  529.   MOVE.L  pfad(A6), -(SP)
  530.   MOVE.W  #57, -(SP)
  531.   TRAP    #1
  532.   ADDQ.L  #6, SP
  533.   MOVE.W  D0, i
  534.  END;
  535.  RETURN i;
  536.  
  537.  
  538.  
  539.  
  540. END Dcreate;
  541.  
  542. PROCEDURE Ddelete (REF pfad: ARRAY OF CHAR): sINTEGER;
  543. BEGIN
  544.  
  545.  ASSEMBLER
  546.   MOVE.L  pfad(A6), -(SP)
  547.   MOVE.W  #58, -(SP)
  548.   TRAP    #1
  549.   ADDQ.L  #6, SP
  550.   MOVE.W  D0, i
  551.  END;
  552.  RETURN i;  
  553.  
  554.  
  555.  
  556.  
  557. END Ddelete;
  558.  
  559. PROCEDURE Dsetpath (REF pfad: ARRAY OF CHAR): sINTEGER;
  560. BEGIN
  561.  
  562.  ASSEMBLER
  563.   MOVE.L  pfad(A6), -(SP)
  564.   MOVE.W  #59, -(SP)
  565.   TRAP    #1
  566.   ADDQ.L  #6, SP
  567.   MOVE.W  D0, i
  568.  END;
  569.  RETURN i;  
  570.  
  571.  
  572.  
  573.  
  574. END Dsetpath;
  575.  
  576. PROCEDURE Fcreate (REF name: ARRAY OF CHAR; attr: sBITSET): sINTEGER;
  577. BEGIN
  578.  
  579.  ASSEMBLER
  580.   MOVE.W  attr(A6), -(SP)
  581.   MOVE.L  name(A6), -(SP)
  582.   MOVE.W  #60, -(SP)
  583.   TRAP    #1
  584.   ADDQ.L  #8, SP
  585.   MOVE.W  D0, i
  586.  END;
  587.  RETURN i;
  588.  
  589.  
  590.  
  591.  
  592. END Fcreate;
  593.  
  594. PROCEDURE Fopen (REF name: ARRAY OF CHAR; mode: sBITSET): sINTEGER;
  595. BEGIN
  596.  
  597.  ASSEMBLER
  598.   MOVE.W  mode(A6), -(SP)
  599.   MOVE.L  name(A6), -(SP)
  600.   MOVE.W  #61, -(SP)
  601.   TRAP    #1
  602.   ADDQ.L  #8, SP
  603.   MOVE.W  D0, i
  604.  END;
  605.  RETURN i;  
  606.  
  607.  
  608.  
  609.  
  610. END Fopen;
  611.  
  612. PROCEDURE Fclose (handle: sINTEGER): sINTEGER;
  613. BEGIN
  614.  
  615.  ASSEMBLER
  616.   MOVE.W  handle(A6), -(SP)
  617.   MOVE.W  #62, -(SP)
  618.   TRAP    #1
  619.   ADDQ.L  #4, SP
  620.   MOVE.W  D0, i
  621.  END;
  622.  RETURN i;
  623.  
  624.  
  625.  
  626.  
  627. END Fclose;
  628.  
  629. PROCEDURE Fread (handle: sINTEGER; VAR count: lCARDINAL; buffer: ADDRESS);
  630. BEGIN
  631.  
  632.  lc:= count;
  633.  ASSEMBLER
  634.   MOVE.L  buffer(A6), -(SP)
  635.   MOVE.L  lc, -(SP)
  636.   MOVE.W  handle(A6), -(SP)
  637.   MOVE.W  #63, -(SP)
  638.   TRAP    #1
  639.   LEA     $C(SP), SP
  640.   MOVE.L  D0, lc
  641.  END;
  642.  count:= lc;
  643.  
  644.  
  645.  
  646.  
  647. END Fread;
  648.  
  649. PROCEDURE Fwrite (handle: sINTEGER; VAR count: lCARDINAL; buffer: ADDRESS);
  650. BEGIN
  651.  
  652.  lc:= count;
  653.  ASSEMBLER
  654.   MOVE.L  buffer(A6), -(SP)
  655.   MOVE.L  lc, -(SP)
  656.   MOVE.W  handle(A6), -(SP)
  657.   MOVE.W  #64, -(SP)
  658.   TRAP    #1
  659.   LEA     $C(SP), SP
  660.   MOVE.L  D0, lc
  661.  END;
  662.  count:= lc;
  663.  
  664.  
  665.  
  666.  
  667. END Fwrite;
  668.  
  669. PROCEDURE Fdelete (REF name: ARRAY OF CHAR): BOOLEAN;
  670. BEGIN
  671.  
  672.  ASSEMBLER
  673.   MOVE.L  name(A6), -(SP)
  674.   MOVE.W  #65, -(SP)
  675.   TRAP    #1
  676.   ADDQ.L  #6, SP
  677.   MOVE.W  D0, x
  678.  END;
  679.  RETURN x = 0;
  680.  
  681.  
  682.  
  683.  
  684. END Fdelete;
  685.  
  686. PROCEDURE Fseek (offset: lINTEGER; handle, mode: sINTEGER): lCARDINAL;
  687. BEGIN
  688.  
  689.  ASSEMBLER
  690.   MOVE.W  mode(A6), -(SP)
  691.   MOVE.W  handle(A6), -(SP)
  692.   MOVE.L  offset(A6), -(SP)
  693.   MOVE.W  #66, -(SP)
  694.   TRAP    #1
  695.   LEA     $A(SP), SP
  696.   MOVE.L  D0, lc
  697.  END;
  698.  RETURN lc;
  699.  
  700.  
  701.  
  702.  
  703. END Fseek;
  704.  
  705. PROCEDURE Fattrib (REF name: ARRAY OF CHAR; set: BOOLEAN; VAR attr: sBITSET);
  706. BEGIN
  707.  IF set THEN  c:= 1;  ELSE  c:= 0;  END;
  708.  
  709.  s := attr;
  710.  ASSEMBLER
  711.   MOVE.W  s, -(SP)
  712.   MOVE.W  c, -(SP)
  713.   MOVE.L  name(A6), -(SP)
  714.   MOVE.W  #67, -(SP)
  715.   TRAP    #1
  716.   LEA     $A(SP), SP
  717.   MOVE.W  D0, s
  718.  END; 
  719.  attr:= s;
  720.  
  721.  
  722.  
  723.  
  724. END Fattrib;
  725.  
  726. PROCEDURE Fdup (handle: sINTEGER): sINTEGER;
  727. BEGIN
  728.  
  729.  ASSEMBLER
  730.   MOVE.W  handle(A6), -(SP)
  731.   MOVE.W  #69, -(SP)
  732.   TRAP    #1
  733.   ADDQ.L  #4, SP
  734.   MOVE.W  D0, i
  735.  END;
  736.  RETURN i;
  737.  
  738.  
  739.  
  740.  
  741. END Fdup;
  742.             
  743. PROCEDURE Fforce (std, nonstd: sINTEGER): BOOLEAN;
  744. BEGIN
  745.  
  746.  ASSEMBLER
  747.   MOVE.W  nonstd(A6), -(SP)
  748.   MOVE.W  std(A6), -(SP)
  749.   MOVE.W  #70, -(SP)
  750.   TRAP    #1
  751.   ADDQ.L  #6, SP
  752.   MOVE.W  D0, x
  753.  END;
  754.  RETURN x # 0;
  755.  
  756.  
  757.  
  758.  
  759. END Fforce;
  760.  
  761. PROCEDURE Dgetpath (VAR pfad: ARRAY OF CHAR; drive: sCARDINAL);
  762. BEGIN
  763.  
  764.  ASSEMBLER
  765.   MOVE.W  drive(A6), -(SP)
  766.   MOVE.L  pfad(A6), -(SP)
  767.   MOVE.W  #71, -(SP)
  768.   TRAP    #1
  769.   ADDQ.L  #8, SP
  770.  END;
  771.  
  772.  
  773.  
  774.  
  775. END Dgetpath;
  776.  
  777. PROCEDURE Malloc (bytes: lCARDINAL): ADDRESS;
  778. BEGIN
  779.  
  780.  ASSEMBLER
  781.   MOVE.L  bytes(A6), -(SP)
  782.   MOVE.W  #72, -(SP)
  783.   TRAP    #1
  784.   ADDQ.L  #6, SP
  785.   MOVE.L  D0, a
  786.  END;
  787.  RETURN a;
  788.  
  789.  
  790.  
  791.  
  792. END Malloc;
  793.  
  794. PROCEDURE Mfree (addr: ADDRESS): BOOLEAN;
  795. BEGIN
  796.  
  797.  ASSEMBLER
  798.   MOVE.L  addr(A6), -(SP)
  799.   MOVE.W  #73, -(SP)
  800.   TRAP    #1
  801.   ADDQ.L  #6, SP
  802.   MOVE.W  D0, x
  803.  END;
  804.  RETURN x = 0;  
  805.  
  806.  
  807.  
  808.  
  809. END Mfree;
  810.  
  811. PROCEDURE Mshrink (addr: ADDRESS; newSize: lCARDINAL): BOOLEAN;
  812. BEGIN
  813.  
  814.  ASSEMBLER
  815.   MOVE.L  newSize(A6), -(SP)
  816.   MOVE.L  addr(A6), -(SP)
  817.   MOVE.W  #0, -(SP)
  818.   MOVE.W  #74, -(SP)
  819.   TRAP    #1
  820.   LEA     $C(SP), SP
  821.   MOVE.W  D0, x
  822.  END;
  823.  RETURN x = 0;
  824.  
  825.  
  826.  
  827.  
  828. END Mshrink;
  829.  
  830. PROCEDURE Pexec (mode: sCARDINAL; VAR name, tail, env: ARRAY OF CHAR): sINTEGER;
  831. BEGIN
  832.  
  833.  IF env[0] = 0C THEN  a:= ADDRESS(0);  ELSE  a:= ADR(env);  END;
  834.  ASSEMBLER
  835.   MOVE.L  a, -(SP)
  836.   MOVE.L  tail(A6), -(SP)
  837.   MOVE.L  name(A6), -(SP)
  838.   MOVE.W  mode(A6), -(SP)
  839.   MOVE.W  #75, -(SP)
  840.   TRAP    #1
  841.   LEA     $10(SP), SP
  842.   MOVE.W  D0, i
  843.  END;
  844.  RETURN i;
  845.  
  846.  
  847.  
  848.  
  849. END Pexec;
  850.  
  851. PROCEDURE Pterm (code: sINTEGER);
  852. BEGIN
  853.  
  854.  ASSEMBLER
  855.   MOVE.W  code(A6), -(SP)
  856.   MOVE.W  #76, -(SP)
  857.   TRAP    #1
  858.  END;
  859.  
  860.  
  861.  
  862.  
  863. END Pterm;
  864.  
  865. PROCEDURE Fsfirst (REF name: ARRAY OF CHAR; attr: sBITSET): sINTEGER;
  866. BEGIN
  867.  
  868.  ASSEMBLER
  869.   MOVE.W  attr(A6), -(SP)
  870.   MOVE.L  name(A6), -(SP)
  871.   MOVE.W  #78, -(SP)
  872.   TRAP    #1
  873.   ADDQ.L  #8, SP
  874.   MOVE.W  D0, i
  875.  END;
  876.  RETURN i;
  877.  
  878.  
  879.  
  880.  
  881. END Fsfirst;
  882.  
  883. PROCEDURE Fsnext (): sINTEGER;
  884. BEGIN
  885.  
  886.  ASSEMBLER
  887.   MOVE.W  #79, -(SP)
  888.   TRAP    #1
  889.   ADDQ.L  #2, SP
  890.   MOVE.W  D0, i
  891.  END;
  892.  RETURN i;
  893.  
  894.  
  895.  
  896.  
  897. END Fsnext;
  898.  
  899. PROCEDURE Frename (REF curr, new: ARRAY OF CHAR): sINTEGER;
  900. BEGIN
  901.  
  902.  ASSEMBLER
  903.   MOVE.L  new(A6), -(SP)
  904.   MOVE.L  curr(A6), -(SP)
  905.   MOVE.W  #0, -(SP)
  906.   MOVE.W  #86, -(SP)
  907.   TRAP    #1
  908.   LEA     $C(SP), SP
  909.   MOVE.W  D0, i
  910.  END;
  911.  RETURN i;
  912.  
  913.  
  914.  
  915.  
  916. END Frename;
  917.  
  918. PROCEDURE Fdatime (handle: sINTEGER; VAR buff: ARRAY OF LOC; set: BOOLEAN);
  919. BEGIN
  920.  IF set THEN c:= 1;  ELSE  c:= 0;  END;
  921.  
  922.  ASSEMBLER
  923.   MOVE.W  c, -(SP)
  924.   MOVE.W  handle(A6), -(SP)
  925.   MOVE.L  buff(A6), -(SP)
  926.   MOVE.W  #87, -(SP)
  927.   TRAP    #1
  928.   LEA     $A(SP), SP
  929.  END;
  930.  
  931.  
  932.  
  933.  
  934. END Fdatime;
  935.  
  936. PROCEDURE Mxalloc (bytes: lCARDINAL; mode: sINTEGER): ADDRESS;
  937. BEGIN
  938.  
  939.  ASSEMBLER
  940.   MOVE.W  mode(A6), -(SP)
  941.   MOVE.L  bytes(A6), -(SP)
  942.   MOVE.W  #68, -(SP)
  943.   TRAP    #1
  944.   ADDQ.L  #8, SP
  945.   MOVE.L  D0, a
  946.  END;
  947.  RETURN  a;
  948.  
  949.  
  950.  
  951.  
  952. END Mxalloc;
  953.  
  954. PROCEDURE Maddalt (start: ADDRESS; size: lCARDINAL): sINTEGER;
  955. BEGIN
  956.  
  957.  ASSEMBLER
  958.   MOVE.L  size(A6), -(SP)
  959.   MOVE.L  start(A6), -(SP)
  960.   MOVE.W  #20, -(SP)
  961.   TRAP    #1
  962.   LEA     $A(SP), SP
  963.   MOVE.W  D0, i
  964.  END;
  965.  RETURN  i;
  966.  
  967.  
  968.  
  969.  
  970. END Maddalt;
  971.  
  972. PROCEDURE Flock (handle, mode: sINTEGER; start, length: lCARDINAL);
  973. BEGIN
  974.  
  975.  ASSEMBLER
  976.   MOVE.L  length(A6), -(SP)
  977.   MOVE.L  start(A6), -(SP)
  978.   MOVE.W  mode(A6), -(SP)
  979.   MOVE.W  handle(A6), -(SP)
  980.   MOVE.W  #92, -(SP)
  981.   TRAP    #1
  982.   LEA     $E(SP), SP
  983.  END;
  984.  
  985.  
  986.  
  987.  
  988. END Flock;
  989.  
  990. END MagicDOS.
  991.  
  992.